#ifndef _M_SERVER_H_
#define _M_SERVER_H_
#include <iostream>
#include <string>
#include <unistd.h>
#include <fcntl.h>
#include <vector>
#include <cstring>
#include <cassert>
#include <typeinfo>
#include <algorithm>
#include <memory>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <functional>
#include <signal.h>
#include <thread>
#include <unordered_map>
#include <mutex>
#include <sys/eventfd.h>
#include <sys/epoll.h>
#include <sys/timerfd.h>
#include <condition_variable>
#include "Log.hpp"
#define BUFFER_DEFAULT_SIZE 1024

using namespace LogModule;
class Buffer
{
public:
    Buffer() : _read_idx(0), _write_idx(0), _buffer(BUFFER_DEFAULT_SIZE)
    {
    }
    char *Begin()
    {
        // 第一个元素的地址
        return &*_buffer.begin();
    }
    // 获取当前写入起始地址,_buffer的空间起始地址，加上写偏移量
    char *WritePosition() { return Begin() + _write_idx; }
    // 获取当前读取起始地址
    char *ReadPosition() { return Begin() + _read_idx; }
    // 获取缓冲区末尾空闲空间大小 -- 写偏移之后的空闲空间,既总体空间大小减去写偏移
    uint64_t TailIdleSize() const { return _buffer.size() - _write_idx; }
    // 获取缓冲区起始空闲空间大小 -- 读偏移之前的空闲空间
    uint64_t HeadIdleSize() const { return _read_idx; }
    // 获取可读数据大小
    uint64_t ReadableSize() const { return _write_idx - _read_idx; }
    // 将读偏移向后移动
    void MoveReadOffset(uint64_t len)
    {
        if (len == 0)
            return;
        // 向后移动的长度不能超过可读数据大小
        assert(len <= ReadableSize());
        _read_idx += len;
    }
    // 将写偏移向后移动
    void MoveWriteOffset(uint64_t len)
    {
        if (len == 0)
            return;
        // 向后移动的长度不能超过剩余空间
        assert(len <= TailIdleSize());
        _write_idx += len;
    }
    // 确保可写空间足够(整体空闲空间够了，就移动数据，否则，就扩容)
    void EnsureWriteableSpace(uint64_t len)
    {
        // 如果末尾空间大小足够，就直接返回
        if (TailIdleSize() >= len)
            return;
        // 末尾空闲空间不够，则判断加上起始位置的空闲空间大小是否足够，够了就将数据移动到起始位置
        if (HeadIdleSize() + TailIdleSize() >= len)
        {
            // 将数据移动到起始位置
            uint64_t rsz = ReadableSize(); // 把当前数据大小先保存起来
            // 把可读数据拷贝到起始位置
            std::copy(ReadPosition(), ReadPosition() + rsz, Begin());
            _read_idx = 0;    // 读偏移置0
            _write_idx = rsz; // 写偏移置当前数据大小
        }
        else
        {
            // 总体空间不够，需要扩容，不移动数据，直接给写偏移之后扩容足够数据即可
            _buffer.resize(_write_idx + len);
        }
    }
    // 写入数据
    void Write(const void *data, uint64_t len)
    {
        // 1,保证有足够空间 2，拷贝数据进去
        if (len == 0)
            return;
        EnsureWriteableSpace(len);
        const char *d = (const char *)data;
        // 因为data是一个void*的指针，它的步长是不明确的，所以得先强转成char*指针，再拷贝数据
        std::copy(d, d + len, WritePosition());
    }
    void WriteAndPush(const void *data, uint64_t len)
    {
        Write(data, len);
        MoveWriteOffset(len);
    }
    void WriteString(const std::string &data)
    {
        Write(data.c_str(), data.size());
    }
    void WriteStringAndPush(const std::string &data)
    {
        WriteString(data);
        MoveWriteOffset(data.size());
    }
    void WriteBuffer(Buffer &data)
    {
        return Write(data.ReadPosition(), data.ReadableSize());
    }
    void WriteBufferAndPush(Buffer &data)
    {
        WriteBuffer(data);
        MoveWriteOffset(data.ReadableSize()); // 移动写偏移量，因为写入的数据已经包含在内了
    }
    // 读取数据
    void Read(void *buf, uint64_t len)
    {
        // 要求要获取的数据大小，必须小于可读数据大小
        assert(len <= ReadableSize());
        std::copy(ReadPosition(), ReadPosition() + len, (char *)buf);
    }
    // 读完数据之后，要把数据从缓冲区中移除
    void ReadAndPop(void *buf, uint64_t len)
    {
        Read(buf, len);
        MoveReadOffset(len);
    }
    std::string ReadAsString(uint64_t len)
    {
        // 要求要获取的数据大小，必须小于可读数据大小
        assert(len <= ReadableSize());
        std::string str;
        str.resize(len);
        // str.c_str()返回的是一个const char *指针，所以无法正常拷贝，所以采用&str[0]的方式
        // 即获取到第0个元素的地址，即起始地址
        Read(&str[0], len);
        return str;
    }
    std::string ReadAsStringAndPop(uint64_t len)
    {
        assert(len <= ReadableSize());
        std::string str = ReadAsString(len);
        MoveReadOffset(len);
        return str;
    }
    // 在http协议中，找到一行的换行符位置
    const char *FindCRLF()
    {
        // 查找某一个字节的数据
        const void *res = std::memchr(ReadPosition(), '\n', ReadableSize());
        return (const char *)res;
    }
    // 通常获取一行数据，这种情况针对是ASCII字符
    std::string GetLine()
    {
        const char *pos = FindCRLF();
        if (pos == NULL)
        {
            return "";
        }
        // 要带上 "\n"，所以要 + 1,
        return ReadAsString(pos - ReadPosition() + 1);
    }
    std::string GetLineAndPop()
    {
        std::string str = GetLine();
        MoveReadOffset(str.size());
        return str;
    }
    // 清空缓冲区
    void Clear()
    {
        // 把偏移量归0即可
        _read_idx = _write_idx = 0;
    }

private:
    std::vector<char> _buffer; // 使用vector进行内存空间管理，这样不会有 '\0'的影响
    uint64_t _read_idx;        // 读偏移
    uint64_t _write_idx;       // 写偏移
};

#define MAX_LISTEN 1024
class Socket
{
public:
    Socket() : _sockfd(-1)
    {
    }
    Socket(int fd) : _sockfd(fd)
    {
    }
    ~Socket()
    {
        Close();
    }
    int Fd()
    {
        return _sockfd;
    }
    // 创建套接字
    bool Create()
    {
        _sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (_sockfd < 0)
        {
            LOG(LogLevel::ERROR) << "create socket failed";
            return false;
        }
        return true;
    }
    // 绑定地址信息
    bool Bind(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in addr;
        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(addr);
        int ret = bind(_sockfd, (struct sockaddr *)&addr, len);
        if (ret < 0)
        {
            LOG(LogLevel::ERROR) << "bind address failed";
            return false;
        }
        return true;
    }
    // 开始监听
    bool Listen(int backlog = MAX_LISTEN)
    {
        int ret = listen(_sockfd, backlog);
        if (ret < 0)
        {
            LOG(LogLevel::ERROR) << "listen failed";
            return false;
        }
        return true;
    }
    // 向服务器发起连接
    bool Connect(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in addr;
        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(addr);
        int ret = connect(_sockfd, (struct sockaddr *)&addr, len);
        if (ret < 0)
        {
            LOG(LogLevel::ERROR) << "connect server failed";
            return false;
        }
        return true;
    }
    // 获取新连接
    int Accept()
    {
        int newfd = accept(_sockfd, NULL, NULL);
        if (newfd < 0)
        {
            LOG(LogLevel::ERROR) << "accept failed";
            return -1;
        }
        return newfd;
    }
    // 接收数据,ssize_t表示有符号的长整型
    // 通过flag可以把recv设置成非阻塞操作,flag为0表示默认为阻塞
    ssize_t Recv(void *buf, size_t len, int flag = 0)
    {
        ssize_t ret = recv(_sockfd, buf, len, flag);
        if (ret <= 0)
        {
            // EAGAIN 当前socket的接收缓冲区中没有数据了，在非阻塞的情况下才会有这个错误
            // EINTER 表示当前socket的阻塞等待，被信号打断了
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0; // 表示这次接收没有接收到数据，但是连接并没有出错
            }
            LOG(LogLevel::ERROR) << "recv failed";
            return -1;
        }
        // 实际接收的数据长度
        return ret;
    }
    ssize_t NonBlockRecv(void *buf, size_t len)
    {
        // MSG_DONTWAIT非阻塞标志，表示当前接收为非阻塞
        return Recv(buf, len, MSG_DONTWAIT);
    }
    // 发送数据
    ssize_t Send(const void *buf, size_t len, int flag = 0)
    {
        ssize_t ret = send(_sockfd, buf, len, flag);
        if (ret < 0)
        {
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0;
            }
            LOG(LogLevel::ERROR) << "send failed";
            return -1;
        }
        // 有可能buf里的数据并没有发送完
        return ret; // 实际发送的数据长度
    }
    ssize_t NonBlockSend(void *buf, size_t len)
    {
        if (len == 0)
            return 0;
        /// MSG_DONTWAIT非阻塞标志，表示当前发送为非阻塞
        return Send(buf, len, MSG_DONTWAIT);
    }
    //  关闭套接字
    void Close()
    {
        if (_sockfd != -1)
        {
            close(_sockfd);
            _sockfd = -1;
        }
    }
    //  创建一个服务端连接
    bool CreateServer(uint16_t port, const std::string &ip = "0.0.0.0", bool block_flag = false)
    {
        // 1,创建套接字 2，绑定地址 3，开始监听 4，设置非阻塞 5，启动地址重用
        if (Create() == false)
            return false;
        // 默认为阻塞
        if (block_flag)
            NonBlock();
        if (Bind(ip, port) == false)
            return false;
        if (Listen() == false)
            return false;

        ReuseAddress();
        return true;
    }
    // 创建一个客户端连接
    bool CreateClient(uint16_t port, const std::string &ip)
    {
        // 1,创建套接字 2，连接服务器
        if (Create() == false)
            return false;
        if (Connect(ip, port) == false)
            return false;
        return true;
    }
    // 设置套接字选项---开启地址端口重用
    void ReuseAddress()
    {
        int val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &val, sizeof(val));
    }
    // 设置套接字选项---设置为非阻塞
    void NonBlock()
    {
        int flag = fcntl(_sockfd, F_GETFL, 0);
        fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
    }

private:
    int _sockfd;
};
class Poller;
class EventLoop;
class Channel
{
public:
    using EventCallback = std::function<void()>;
    // 要传入描述符，因为是对描述符的事件管理
    Channel(EventLoop *loop, int sockfd) : _fd(sockfd), _events(0), _revents(0), _loop(loop)
    {
    }
    // 外部会通过这个接口来设置就绪的事件
    void SetRevents(uint32_t revents)
    {
        _revents = revents;
    }
    int Fd()
    {
        return _fd;
    }
    int32_t Events() { return _events; } // 获取想要监控的事件
    void SetReadCallback(const EventCallback &cb) { _read_callback = cb; }
    void SetWriteCallback(const EventCallback &cb) { _write_callback = cb; }
    void SetErrorCallback(const EventCallback &cb) { _error_callback = cb; }
    void SetCloseCallback(const EventCallback &cb) { _close_callback = cb; }
    void SetEventCallback(const EventCallback &cb) { _event_callback = cb; }
    bool Readable() // 当前是否可读
    {
        return (_revents & EPOLLIN);
    }
    bool Writeable() // 当前是否可写
    {
        return (_revents & EPOLLOUT);
    }
    void EnableRead() // 启动读事件监控
    {
        _events |= EPOLLIN; // 后面会添加到EventLoop的事件监控中
        Update();
    }
    void EnableWrite() // 启动写事件监控
    {
        _events |= EPOLLOUT; // 后面会添加到EventLoop的事件监控中
        Update();
    }
    void DisableRead() // 关闭读事件监控
    {
        _events &= ~EPOLLIN; // 后面会从EventLoop的事件监控中移除
        Update();
    }
    void DisableWrite() // 关闭写事件监控
    {
        _events &= ~EPOLLOUT; // 后面会从EventLoop的事件监控中移除
        Update();
    }
    void DisableAll() // 关闭所有事件监控
    {
        _events = 0;
        Update();
    }
    void Update();
    // 移除监控，即从epoll的红黑树上，把对应节点移除
    void Remove();
    // 事件处理，一旦连接触发了这个事件，就调用这个函数
    // 这个函数内部，再去根据revents判断，是哪个事件触发的，然后调用相应的回调函数
    void HandleEvent() // eventloop模块只管监控，不管怎么对事件进行处理，自己触发了什么事件由channel自己处理
    {
        // EPOLLRDHUP表示对方的连接关闭,半关闭连接,也就是对方已经不会发送数据了，我们要把缓冲区中剩余的数据读完
        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
        {
            if (_read_callback)
                _read_callback();
        }
        // 有可能会释放连接的操作事件，一次只处理一个
        // 比如写事件，如果写入失败的时候，连接断开，就不能再继续执行下面的事件回调了
        if (_revents & EPOLLOUT)
        {
            if (_write_callback)
                _write_callback();
        }
        else if (_revents & EPOLLERR) // 一旦出错，就会释放连接，因此要放到错误回调的前面
        {
            if (_error_callback)
                _error_callback();
        }
        // 连接关闭
        else if (_revents & EPOLLHUP)
        {
                _close_callback();
        }
        // 不管任何事件，都调用的回调函数，但是这个回调，不会再事件出错的时候被调用，只会在读写事件处理完后调用
        // 放到事件处理完毕后调用，刷新活跃度，因为写事件可能会要处理很久，为了不让连接因为超时被释放
        // 在一个很长的事件之后，我们需要刷新活跃度，让连接活跃起来
        if (_event_callback)
            _event_callback();
    }

private:
    EventLoop *_loop;
    int _fd;                       // 套接字描述符
    uint32_t _events;              // 当前需要监控的事件
    uint32_t _revents;             // 当前连接触发的事件
    EventCallback _read_callback;  // 可读事件触发的回调函数
    EventCallback _write_callback; // 可写事件触发的回调函数
    EventCallback _error_callback; // 错误事件触发的回调函数
    EventCallback _close_callback; // 关闭事件触发的回调函数
    EventCallback _event_callback; // 任意事件触发的回调函数
};
using TaskFunc = std::function<void()>;
using ReleaseFunc = std::function<void()>;
class TimerTask
{
public:
    TimerTask(uint64_t id, uint32_t delay, const TaskFunc &task_cb)
        : _id(id), _timeout(delay), _task_cb(task_cb)
    {
    }
    ~TimerTask()
    {
        // 如果被取消了，就不用执行回调了
        if (!_canceld)
        {
            _task_cb();
        }
        // 但是，仍然需要把它释放
        _release();
    }
    void SetRelease(const ReleaseFunc &release_cb)
    {
        _release = release_cb;
    }
    uint32_t DelayTime()
    {
        return _timeout;
    }
    void Cancel()
    {
        _canceld = true;
    }

private:
    uint64_t _id;          // 通过id找到定时器任务，并且因为任务可能会有很多，所以id用uint64_t类型
    uint32_t _timeout;     // 超时时间
    TaskFunc _task_cb;     // 定时器对象要执行的定时任务
    ReleaseFunc _release;  // 用于删除TimerWheel中保存的定时器任务对象信息
    bool _canceld = false; // 用于标记任务是否被取消了，false表示没有被取消，true表示被取消
};
class TimerWheel
{
public:
    using PtrTask = std::shared_ptr<TimerTask>;
    using WeakTask = std::weak_ptr<TimerTask>;
    TimerWheel(EventLoop *loop) : _capacity(60), _tick(0),
                                  _wheel(_capacity),
                                  _loop(loop),
                                  _timerfd(CreateTimerFd()),
                                  _timer_channel(std::make_unique<Channel>(loop, _timerfd))
    {
        _timer_channel->SetReadCallback(std::bind(&TimerWheel::OnTime, this)); // 设置读事件回调
        _timer_channel->EnableRead();                                          // 启动读事件监控
    }
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &task_cb);
    // 这里也同理，因为它也对_timers操作了
    void TimerRefresh(uint64_t id);
    void TimerCancel(uint64_t id);
    // 这个函数应该每秒钟被执行一次，相当于秒针向后走了一步
    void RunTimerTask()
    {
        _tick = (_tick + 1) % _capacity;
        // clear的作用是释放对象，但是不释放空间。
        _wheel[_tick].clear(); // 清空指定位置的数组，就会把数组中保存的所有管理定时器对象的shared_ptr释放掉。
    }

    // 这个接口存在线程安全问题，这个接口实际上不能被外界使用者调用，只能在模块内，在对应的EventLoop线程内执行
    bool HasTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return false;
        }
        return true;
    }
    int ReadTimerFd()
    {
        uint64_t times;
        // 有可能因为其他描述符的事件处理花费时间比较长，然后在处理定时器描述符事件的时候，有可能已经超时很多次了
        // read读取到的数据times就是从上一次read之后超时的次数，读取一次之后，计数器归0
        int ret = read(_timerfd, &times, sizeof(times));
        if (ret < 0)
        {
            LOG(LogLevel::ERROR) << "read timerfd failed";
            abort();
        }
        return times;
    }
    void OnTime()
    {
        // 根据实际超时的次数，来执行对应的超时任务
        int times = ReadTimerFd(); // 读一下定时器是为了把内容清空
        for (int i = 0; i < times; i++)
            RunTimerTask(); // 执行定时任务
    }

private:
    // 添加定时器任务
    void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc &task_cb)
    {
        PtrTask pt(new TimerTask(id, delay, task_cb));
        pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
        _timers[id] = WeakTask(pt);
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
    }
    // 刷新/延迟定时任务
    void TimerRefreshInLoop(uint64_t id)
    {
        // 通过保存的定时器的weak_ptr，构造一个shared_ptr，添加到时间轮中
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            // 没找着定时器任务，没法刷新
            return;
        }
        PtrTask pt = it->second.lock(); // 用来获取weak_ptr管理的对象的对应的shared_ptr
        int delay = pt->DelayTime();
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt); // 这里的pt会在push_back进vector的时候，拷贝一份，然后智能指针引用计数++
        // 但是pt出了这个函数作用域以后，就会被销毁，引用计数又减为1，所以这里的拷贝是正确的
    }
    // 用于取消一个定时任务
    void TimerCancelInLoop(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return;
        }
        PtrTask pt = it->second.lock();
        if (pt)
            pt->Cancel();
    }
    void RemoveTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it != _timers.end())
            _timers.erase(id);
    }
    static int CreateTimerFd()
    {
        int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
        if (timerfd < 0)
        {
            LOG(LogLevel::ERROR) << "create timerfd failed";
            abort();
        }
        struct itimerspec itime;
        itime.it_value.tv_sec = 1;
        itime.it_value.tv_nsec = 0;
        itime.it_interval.tv_sec = 1;
        itime.it_interval.tv_nsec = 0;
        timerfd_settime(timerfd, 0, &itime, NULL);
        return timerfd;
    }

private:
    // 可读事件回调，就是读取计数器，执行定时任务
    int _timerfd; // 定时器描述符，一旦超时一次，就读取一次定时器数据，运行一次时间轮
    EventLoop *_loop;
    std::unique_ptr<Channel> _timer_channel; // 管理定时器描述符的事件监控

    int _tick;                                      // 时间轮指针，走到哪里，就释放哪里的任务指针
    int _capacity;                                  // 时间轮的容量,其实就是最大延迟时间
    std::vector<std::vector<PtrTask>> _wheel;       // 时间轮
    std::unordered_map<uint64_t, WeakTask> _timers; // 任务id和任务的映射
};
#define MAX_EPOLLEVENTS 1024
class Poller
{
public:
    Poller()
    {
        _epfd = epoll_create(256);
        if (_epfd < 0)
        {
            LOG(LogLevel::ERROR) << "epoll_create failed";
            abort(); // 退出程序
        }
    }
    // 对channel进行操作，因为channel既包含了文件描述符，又包含了要关心的事件
    // 添加或修改事件
    void UpdateEvent(Channel *channel)
    {
        bool ret = HasChannel(channel);
        if (ret == false) // 不存在，则添加
        {
            Update(channel, EPOLL_CTL_ADD);
            _channels[channel->Fd()] = channel;
        }
        else
        {
            Update(channel, EPOLL_CTL_MOD); // 存在，则修改
        }
    }
    // 移除监控
    void RemoveEvent(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it != _channels.end())
        {
            _channels.erase(it);
        }
        Update(channel, EPOLL_CTL_DEL);
    }
    // 开始监控，返回活跃的连接
    void Poll(std::vector<Channel *> *active)
    {
        int nfds = epoll_wait(_epfd, _events, MAX_EPOLLEVENTS, -1); //  阻塞等待
        if (nfds < 0)
        {
            if (errno == EINTR)
                return; // 被信号打断，下次可以继续监控
            LOG(LogLevel::ERROR) << "epoll_wait error";
            abort(); // 退出程序
        }
        for (int i = 0; i < nfds; i++)
        {
            auto it = _channels.find(_events[i].data.fd); // 这必须应该找到
            assert(it != _channels.end());                // 直接断言
            it->second->SetRevents(_events[i].events);    // 设计实际就绪的事件
            active->push_back(it->second);
        }
    }

private:
    // 实际对epoll的直接操作
    void Update(Channel *channel, int op)
    {
        // int epoll_ctl(int epfd, int op, int fd, struct epoll_event *ev);
        int fd = channel->Fd();
        struct epoll_event ev;
        ev.data.fd = fd;
        ev.events = channel->Events();
        int ret = epoll_ctl(_epfd, op, fd, &ev);
        if (ret < 0)
        {
            LOG(LogLevel::ERROR) << "epoll_ctl error";
            std::cout << "errno:" << errno << std::endl;
        }
        return;
    }
    // 判断一个channel是否已经添加了事件监控
    bool HasChannel(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it == _channels.end())
        {
            return false;
        }
        return true;
    }

private:
    int _epfd;
    struct epoll_event _events[MAX_EPOLLEVENTS];
    std::unordered_map<int, Channel *> _channels;
};

class EventLoop
{
public:
    static int CreateEventFd()
    {
        int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
        if (efd < 0)
        {
            LOG(LogLevel::ERROR) << "create eventfd failed";
            abort();
        }
        return efd;
    }
    void ReadEventFd()
    {
        uint64_t res = 0;
        int ret = read(_eventfd, &res, sizeof(res));
        if (ret < 0)
        {
            // 被信号打断或者无数据可读，都不用管
            if (errno == EINTR || errno == EAGAIN)
            {
                return;
            }
            LOG(LogLevel::ERROR) << "read eventfd failed";
            abort();
        }
    }
    void WakeUpEventFd()
    {
        uint64_t val = 1;
        int ret = write(_eventfd, &val, sizeof(val));
        if (ret < 0)
        {
            if (errno == EINTR || errno == EAGAIN)
            {
                return;
            }
            LOG(LogLevel::ERROR) << "write eventfd failed";
            abort();
        }
    }

    using Functor = std::function<void()>;
    EventLoop() : _thread_id(std::this_thread::get_id()),
                  _eventfd(CreateEventFd()),
                  _event_channel(new Channel(this, _eventfd)),
                  _timer_wheel(this)
    {
        // 对于_eventfd，我们对它的操作有两个，一个读操作，一个写操作
        // 给_eventfd添加可读事件回调函数，读取eventfd事件通知次数
        _event_channel->SetReadCallback(std::bind(&EventLoop::ReadEventFd, this));
        // 启动eventfd的读事件监控
        _event_channel->EnableRead();
    }
    void Start() // 三步走--事件监控--就绪事件处理--执行任务
    {
        while (1)
        {
            // 1，事件监控
            std::vector<Channel *> actives;
            _poller.Poll(&actives);
            // 2，事件处理
            for (auto &channel : actives)
            {
                channel->HandleEvent(); // 处理事件
            }
            // 3，执行任务
            RunAllTask();
        }
    }
    bool IsInLoop() // 判断当前线程是否是EventLoop对应的线程
    {
        return std::this_thread::get_id() == _thread_id;
    }
    void AssertInLoop()
    {
        assert(IsInLoop());
    }
    void RunInLoop(const Functor &cb) // 判断将要执行的任务是否处于当前线程中，如果是，则直接执行，否则放入任务池
    {
        if (IsInLoop())
            return cb();
        return QueueInLoop(cb);
    }
    void QueueInLoop(const Functor &cb) // 将操作压入任务池
    {
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _tasks.push_back(cb); // 压入任务池
        }
        // 唤醒有可能因为没有事件就绪，而导致的epoll阻塞
        // 其实就是给eventfd写入一个数据，eventfd就会触发可读事件
        // eventfd不管写入多少次，读一次就会把数据全部读完，并且效率也很高，因为它只是一个8字节的计数器
        // 这里没有线程安全问题
        WakeUpEventFd();
    }

    void UpdateEvent(Channel *channel) // 添加/修改 描述符的事件监控
    {
        return _poller.UpdateEvent(channel);
    }
    void RemoveEvent(Channel *channel) // 移除描述符监控
    {
        return _poller.RemoveEvent(channel);
    }
    // 添加定时器任务
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &task_cb)
    {
        _timer_wheel.TimerAdd(id, delay, task_cb);
    }
    void TimerRefresh(uint64_t id) // 刷新/延迟定时器任务
    {
        _timer_wheel.TimerRefresh(id);
    }
    void TimerCancel(uint64_t id) // 取消定时器任务
    {
        _timer_wheel.TimerCancel(id);
    }
    // 判断是否有某个定时器任务的存在
    bool HasTimer(uint64_t id)
    {
        return _timer_wheel.HasTimer(id);
    }

private:
    void RunAllTask() // 执行任务池中的所有任务
    {
        std::vector<Functor> functor;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _tasks.swap(functor); // 先把任务池中的任务拿出来，放到临时变量中
        }
        for (auto &f : functor)
        {
            f(); // 执行任务
        }
        return;
    }

private:
    std::thread::id _thread_id;              // 线程id,判断某个操作跟它EventLoop里所保存的线程ID是否是一样的，一样就表示就在这个线程里
    int _eventfd;                            // eventfd唤醒IO事件监控有可能导致的阻塞
    std::unique_ptr<Channel> _event_channel; // 通过它，来管理_eventfd的事件监控，因为_eventfd也是一个文件描述符
    Poller _poller;                          // 进行所有描述符的事件监控
    std::vector<Functor> _tasks;             // 任务池
    std::mutex _mutex;                       // 实现任务池操作的线程安全
    TimerWheel _timer_wheel;                 // 定时器管理器
};
class LoopThread
{
public:
    // 创建线程，设定线程入口函数
    LoopThread() : _loop(NULL), _thread(std::thread(std::bind(&LoopThread::ThreadEntry, this)))
    {
    }
    EventLoop *GetLoop() // 返回当前线程关联的EventLoop对象指针给外界获取
    {
        EventLoop *loop = NULL;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            // 为了防止loop还没创建好的时候，就被外界其他线程获取，如果获取到一个空的，然后绑定给connection，就会出错
            // 使用条件遍历，满足条件(即_loop被创建好)，则被唤醒后继续向后执行,loop为NULL，则一直阻塞
            _cond.wait(lock, [&]()
                       { return _loop != NULL; });
            loop = _loop;
        }
        return loop;
    }

private:
    // 实例化EventLoop对象，唤醒cond上有可能阻塞的线程，并且开始运行EventLoop模块的功能
    void ThreadEntry()
    {
        EventLoop loop; // 直接实例化对象，而不是new一个对象
        // 因为我们想让_loop，它的生命周期随LoopThread，由LoopThread来管理它的生命周期
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _loop = &loop;
            _cond.notify_all();
        }
        _loop->Start(); // 启动EventLoop模块的功能
    }

private:
    // 这两个变量是为了实现_loop获取的同步关系
    // 避免线程创建了但是还没有实例化loop的时候，外界去获取loop，这样的获取是有问题的
    std::mutex _mutex;             // 互斥锁
    std::condition_variable _cond; // 条件变量

    EventLoop *_loop;    // EventLoop指针变量，EventLoop对象需要在线程内实例化，然后用它来指向，所以用指针变量保存
    std::thread _thread; // EventLoop对应的线程
};

class LoopThreadPool
{
public:
    LoopThreadPool(EventLoop *baseloop) : _baseloop(baseloop), _next_idx(0), _thread_count(0)
    {
    }
    void SetThreadCount(int num) // 设置线程数量
    {
        _thread_count = num;
    }
    void Create()
    {
        if (_thread_count > 0)
        {
            _threads.resize(_thread_count);
            _loops.resize(_thread_count);
            for (int i = 0; i < _thread_count; i++)
            {
                _threads[i] = new LoopThread(); 
                // 在创建该对象的时候，如果loop还没有实例化，下面的GetLoop()则会阻塞
                _loops[i] = _threads[i]->GetLoop();
            }
        }
        return;
    }
    EventLoop *NextLoop()
    {
        if (_thread_count == 0)
            return _baseloop;
        _next_idx = (_next_idx + 1) % _thread_count;
        return _loops[_next_idx];
    }

private:
    int _thread_count; // 从属线程的数量
    int _next_idx;
    EventLoop *_baseloop;
    std::vector<LoopThread *> _threads;
    std::vector<EventLoop *> _loops;
};
class Any
{
public:
    Any() : _content(nullptr) {}
    template <class T>
    Any(const T &val) : _content(new placeholder<T>(val))
    {
    }
    Any(const Any &other) : _content(other._content ? other._content->clone() : nullptr)
    {
    }
    ~Any()
    {
        delete _content;
    }
    Any &swap(Any &other)
    {
        std::swap(_content, other._content);
        return *this;
    }
    // 返回子类对象保存的数据的指针
    template <class T>
    T *get()
    {
        // 想要获取的数据的类型，必须和保存的数据类型一致
        if (typeid(T) != _content->type())
            return nullptr;

        return &((placeholder<T> *)_content)->_val;
    }
    template <class T>
    Any &operator=(const T &val) // 赋值运算符
    {
        // 用val构造一个临时对象，然后和this交换，这样原本的_content会在这个临时对象销毁后释放掉
        // 同时也达到了把this的_content赋值的目的
        Any(val).swap(*this);
        return *this;
    }
    Any &operator=(const Any &other) // 赋值运算符重载
    {
        // 原理同上面，既不影响我们外面的other，还能保证this的_content在交换后能正确释放掉
        Any(other).swap(*this);
        return *this;
    }

private:
    class holder
    {
    public:
        virtual ~holder() {}
        virtual const std::type_info &type() = 0;
        virtual holder *clone() = 0;
    };
    template <class T>
    class placeholder : public holder
    {
    public:
        placeholder(const T &val) : _val(val) {}
        virtual const std::type_info &type() // 获取子类对象保存的数据类型
        {
            return typeid(T);
        }
        virtual holder *clone() // 针对当前的对象自身，克隆出一个新的子类对象
        {
            return new placeholder(_val);
        }
        T _val;
    };
    holder *_content;
};
// DISCONNECTED--连接关闭状态, CONNECTING--连接建立成功，待处理状态
// CONNECTED--连接建立完成, 各种设置已完成，可以通信的状态。DISCONNECTING待关闭状态
typedef enum
{
    DISCONNECTED,
    CONNECTING,
    CONNECTED,
    DISCONNECTING
} ConnStatus;

class Connection : public std::enable_shared_from_this<Connection>
{
public:
    using PtrConnection = std::shared_ptr<Connection>;
    // 这种阶段性的回调函数，是提供给外界来进行连接的某种操作，所以参数有连接
    // 这四个回调函数，是让服务器模块来设置的(其实服务器模块的处理回调也是组件使用者设置的)
    // 也就是,这几个回调都是组件使用者使用的
    using ConnectedCallback = std::function<void(const PtrConnection &)>;
    // 把收到数据的缓冲区也提供给该业务回调函数
    using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
    using ClosedCallback = std::function<void(const PtrConnection &)>;
    using AnyEventCallback = std::function<void(const PtrConnection &)>;
    Connection(EventLoop *loop, uint64_t id, int sockfd) : _conn_id(id), _sockfd(sockfd),
                                                           _loop(loop), _status(CONNECTING), // 连接对于上层来说还是半完成状态
                                                           _socket(sockfd), _channel(loop, sockfd)
    {
        _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
        _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
        _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
        _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
    }
    ~Connection()
    {
        LOG(LogLevel::DEBUG) << "Connection " << this << " destroyed";
    }
    void Send(const char *data, int len) // 发送数据，将数据发送到发送缓冲区，启动写事件
    {
        // 外界传入的data，可能是个临时对象，我们现在只是把发送操作压入了任务池，有可能并没有立即执行
        // 因此有可能执行的时候，这个data指向的空间可能已经被释放了
        // 所以我们要用一个临时缓冲区来保存data的数据
        Buffer buf;
        buf.WriteAndPush(data, len);
        // move是因为这个buf后面也不会在用了，直接进行资源转移
        _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf)));
    }
    // 提供给组件使用者的关闭接口，并不实际关闭，需要判断有没有数据待处理
    void ShutDown()
    {
        _loop->RunInLoop(std::bind(&Connection::ShutDownInLoop, this));
    }

    void Release()
    {
        _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
    }
    // 启动非活跃销毁,并定义多长时间无通信才是非活跃，添加定时任务
    void EnableInactiveRelease(int sec)
    {
        _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
    }
    // 取消非活跃销毁
    void CancelInactiveRelease()
    {
        _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
    }
    // 切换协议---重置上下文以及阶段性处理函数(连接建立，收到消息，连接关闭)---这个接口必须在EventLoop线程中立即执行，不能放到队列里
    // 防备新的事件触发后，处理的时候，切换任务还没有被执行--会导致数据使用原协议处理了
    void Upgrade(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg,
                 const ClosedCallback &closed, const AnyEventCallback &any_event)
    {
        _loop->AssertInLoop(); // 确保在EventLoop线程中直接调用
        _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, conn, msg, closed, any_event));
    }
    // 获取管理的文件描述符
    int Fd()
    {
        return _sockfd;
    }
    // 获取连接id
    int Id()
    {
        return _conn_id;
    }
    // 是否处于connected状态
    bool Connected()
    {
        return _status == CONNECTED;
    }
    void SetContext(const Any &context) // 设置上下文--连接建立成功时进行调用
    {
        _context = context;
    }
    Any *GetContext() // 获取上下文， 返回的是指针，保证返回的是同一个
    {
        return &_context;
    }
    void SetConnectedCallback(const ConnectedCallback &cb) // 设置连接建立成功后的回调函数
    {
        _connected_cb = cb;
    }
    void SetMessageCallback(const MessageCallback &cb) // 设置收到数据的回调函数
    {
        _message_cb = cb;
    }
    void SetClosedCallback(const ClosedCallback &cb) // 设置连接关闭的回调函数
    {
        _closed_cb = cb;
    }
    void SetAnyEventCallback(const AnyEventCallback &cb) // 设置任意事件的回调函数
    {
        _any_event_cb = cb;
    }
    void SetServerClosedCallback(const ClosedCallback &cb)
    {
        _server_closed_cb = cb;
    }
    void Established() // 连接建立就绪后,channel设置事件回调,启动读监控,调用_connected_cb
    {
        _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
    }

private:
    // 五个channel的事件回调函数
    // 描述符触发可读事件后回调的函数，接收socket数据到接收缓冲中，然后调用_message_cb
    void HandleRead()
    {
        // 1,接收socket的数据到缓冲区
        char buf[65536];
        ssize_t ret = _socket.NonBlockRecv(buf, 65535);
        if (ret < 0)
        {
            // 出错了不能直接关闭连接，要看发送缓冲区和接收缓冲区是否还有剩余数据
            return ShutDownInLoop();
        }
        // 这里如果ret等于0表示的是没有读取到数据，而不是连接断开了，这里连接断开返回的是-1
        _in_buffer.WriteAndPush(buf, ret);
        // 2,调用message_cb进行业务处理
        if (_in_buffer.ReadableSize() > 0)
        {
            // shared_from_this，返回当前对象自身的智能指针
            return _message_cb(shared_from_this(), &_in_buffer);
        }
    }
    // 描述符触发可写事件后回调的函数，从发送缓冲区取出数据进行发送
    void HandleWrite()
    {
        // _out_buffer中保存的数据就是要发送的数据
        ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadableSize());
        if (ret < 0)
        {
            // 发送错误就该关闭连接了
            if (_in_buffer.ReadableSize() > 0)
            {
                _message_cb(shared_from_this(), &_in_buffer);
            }
            // 这时候就是实际的释放连接操作的
            return Release();
        }
        _out_buffer.MoveReadOffset(ret); // 要记得把读偏移向后移动
        if (_out_buffer.ReadableSize() == 0)
        {
            _channel.DisableWrite(); // 缓冲区中没有数据了，就关闭写事件监控
            // 如果当前连接是待关闭状态
            if (_status == DISCONNECTING)
            {
                // 如果数据发送完了并且连接是待关闭状态，直接释放连接
                return Release();
            }
        }
        return;
    }
    // 描述符触发关闭事件
    void HandleClose()
    {
        // 一旦连接挂断了，套接字就什么都干不了了，因此有数据就处理一下，完毕关闭连接
        if (_in_buffer.ReadableSize() > 0)
        {
            _message_cb(shared_from_this(), &_in_buffer);
        }
        return Release();
    }
    // 描述符触发错误事件
    void HandleError()
    {
        return HandleClose();
    }
    // 描述符触发任意事件: 1,刷新连接的活跃度--延迟定时销毁任务; 2,调用使用者的任意事件回调
    void HandleEvent()
    {
        if (_enable_inactive_release == true)
        {
            _loop->TimerRefresh(_conn_id); // 刷新连接的活跃度
        }
        if (_any_event_cb)
            _any_event_cb(shared_from_this()); // 调用任意事件回调函数
    }

    // 这些操作，都需要在一个线程中完成，因为连接只会由一个线程来绑定
    // 所以要把它们设置到EventLoop的任务池中
    void EstablishedInLoop() // 连接获取之后，所处的状态下要进行各种设置
    {
        // 1.修改连接状态 2.启动读事件监控 3.调用回调函数
        assert(_status == CONNECTING); // 当前状态必须一定是上层的半连接状态
        _status = CONNECTED;           // 当前函数执行完毕，则连接进入已完成连接状态
        // 一旦启动读事件监控，就有可能立即触发读事件，如果这时候启动了非活跃连接销毁
        _channel.EnableRead();
        if (_connected_cb)
            _connected_cb(shared_from_this()); // 调用连接建立成功的回调函数
    }
    // 这个接口并不是实际的发送接口，而只是把数据放到了发送缓冲区，启动了可写事件监控
    // 不要引用，就是为了复制Send函数传入的临时缓冲区，复制之后，就不怕外面的buf的被销毁了
    void SendInLoop(Buffer &buf)
    {
        if (_status == DISCONNECTED)
            return;
        _out_buffer.WriteBufferAndPush(buf);
        if (_channel.Writeable() == false)
            _channel.EnableWrite();
    }
    void ReleaseInLoop() // 实际的释放接口
    {
        LOG(LogLevel::DEBUG) << "Connection " << this << " released";
        // 1.修改连接状态
        _status = DISCONNECTED; // 连接关闭状态
        // 2.移除连接的事件监控
        _channel.Remove();
        // 3.关闭描述符
        _socket.Close();
        // 4.如果当前定时器队列中还有定时销毁任务，则取消任务
        if (_loop->HasTimer(_conn_id))
        {
            CancelInactiveReleaseInLoop();
        }
        // 5.调用连接关闭回调函数,避免先移除服务器的管理信息而导致的Connection被释放，再去处理会出错
        // 所以先调用用户的回调函数，再去移除服务器内部的
        if (_closed_cb)
            _closed_cb(shared_from_this()); // 调用连接关闭的回调函数
        // 移除服务器内部的管理的连接信息
        if (_server_closed_cb)
            _server_closed_cb(shared_from_this()); // 调用服务器关闭连接的回调函数
    }
    // 这个关闭操作并非实际的连接释放操作,需要判断还有没有数据待处理，待发送
    void ShutDownInLoop()
    {
        _status = DISCONNECTING; // 切换到半关闭状态
        if (_in_buffer.ReadableSize() > 0)
        {
            if (_message_cb)
                _message_cb(shared_from_this(), &_in_buffer);
        }
        if (_out_buffer.ReadableSize() > 0)
        {
            if (_channel.Writeable() == false)
                _channel.EnableWrite();
        }
        // 只要发送缓冲区里没数据了，就可以直接关闭连接了
        //  因为接收缓冲区里的数据，对于上层来说可能不够一条完整的请求，没有办法处理，就不会取出去，所以接收缓冲区可能一直不为空
        //  但是我们仍然要关闭连接，所以我们只负责让上层来处理一下接收缓冲区的数据，不关心它处理的怎么样
        // 只需要关心把发送缓冲区的数据发完,这里是考虑到，如果发送缓冲区本来就没有数据，就不会去调用写事件回调，直接关闭连接。  
        if (_out_buffer.ReadableSize() == 0)
        {
            Release();
        }
    }
    // 启动非活跃连接超时释放规则
    void EnableInactiveReleaseInLoop(int sec)
    {
        // 1.将判断标志 _enable_inactive_release 置为true
        _enable_inactive_release = true;
        // 2.添加定时销毁任务，如果当前定时任务已经存在，那就刷新延迟一下即可
        if (_loop->HasTimer(_conn_id))
            return _loop->TimerRefresh(_conn_id);
        // 如果不存在，则新增
        _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
    }
    void CancelInactiveReleaseInLoop()
    {
        _enable_inactive_release = false;
        if (_loop->HasTimer(_conn_id))
            _loop->TimerCancel(_conn_id); // 取消定时销毁任务
    }
    void UpgradeInLoop(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg,
                       const ClosedCallback &closed, const AnyEventCallback &any_event)
    {
        _context = context;
        _connected_cb = conn;
        _message_cb = msg;
        _closed_cb = closed;
        _any_event_cb = any_event;
    }

private:
    uint64_t _conn_id; // 连接的唯一id，便于连接的管理和查找
    // uint64_t _timer_id //定时器ID，当一个连接有事件出发了，就要去刷新这个连接的活跃度，即延迟定时任务的执行
    // 所以我们必须有一个定时器ID，作为一个唯一标识来找到这个连接的对应的定时任务。这里我们简化操作，直接使用_conn_id来作为定时器ID，因为它也是唯一的
    int _sockfd;                   // 连接关联的文件描述符
    bool _enable_inactive_release; // 连接是否启动非活跃销毁的判断标志，默认为false，表示不启动
    EventLoop *_loop;              // 连接所关联的EventLoop，这样连接就关联到一个线程上了
    ConnStatus _status;            // 连接状态
    Socket _socket;                // 套接字对象，来完成对socket的操作管理
    Channel _channel;              // 连接关联的事件管理
    Buffer _in_buffer;             // 输入缓冲区，存放从socket中读取的数据
    Buffer _out_buffer;            // 输出缓冲区，存放要发送给对端的数据
    Any _context;                  // 请求的接收处理上下文

    ConnectedCallback _connected_cb; // 连接建立成功后的回调函数
    MessageCallback _message_cb;     // 收到数据的回调函数
    ClosedCallback _closed_cb;       // 连接关闭的回调函数
    AnyEventCallback _any_event_cb;  // 任意事件的回调函数
    // 组件内部的连接关闭回调--组件内设置的，因为服务器组件内会把所有的连接管理起来，一旦某个连接要关闭
    // 就应该从管理的地方移除掉自己的信息
    ClosedCallback _server_closed_cb; // 服务器关闭连接的回调函数
};

class Acceptor
{
public:
    using AcceptCallback = std::function<void(int)>; // 参数是一个文件描述符
    // 不能将启动读事件监控的行为，放到构造函数中，必须在设置回调函数后，再去启动
    // 否则有可能造成启动监控后，立即有事件，处理的时候，回调函数还没设置，新连接就得不到处理，且资源泄露
    Acceptor(EventLoop *loop, int port) : _loop(loop), _socket(CreateServer(port)),
                                          _channel(loop, _socket.Fd())
    {
        _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
    }
    void SetAcceptCallback(const AcceptCallback &cb) { _accept_cb = cb; }
    void Listen() { _channel.EnableRead(); } // 启动监听套接字的读事件监控
private:
    void HandleRead() // 监听套接字的读事件回调处理函数，即获取新连接，然后调用_accept_cb函数，进行新连接的处理
    {
        int newfd = _socket.Accept(); // 获取新连接的文件描述符
        if (newfd < 0)
            return;
        if (_accept_cb)
            _accept_cb(newfd); // 调用回调函数，进行新连接的处理
    }
    int CreateServer(int port)
    {
        bool ret = _socket.CreateServer(port); // 创建监听套接字
        assert(ret == true);
        return _socket.Fd(); // 返回监听套接字的文件描述符
    }

private:
    Socket _socket;            // 用于创建监听套接字
    EventLoop *_loop;          // 用于对监听套接字进行事件监控
    Channel _channel;          // 用于对监听套接字进行事件管理
    AcceptCallback _accept_cb; // 回调函数
};

class TcpServer
{
public:
    using ConnectedCallback = std::function<void(const Connection::PtrConnection &)>;
    using MessageCallback = std::function<void(const Connection::PtrConnection &, Buffer *)>;
    using ClosedCallback = std::function<void(const Connection::PtrConnection &)>;
    using AnyEventCallback = std::function<void(const Connection::PtrConnection &)>;
    using Functor = std::function<void()>;
    TcpServer(int port) : _port(port), _next_id(0),
                          _enable_inactive_release(false),
                          _acceptor(&_baseloop, _port),
                          _pool(&_baseloop)
    {
        _acceptor.SetAcceptCallback(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
        _acceptor.Listen();
    }
    void SetThreadCount(int count)
    {
        return _pool.SetThreadCount(count);
    }
    void Start()
    {
        _pool.Create(); // 创建线程池中的从属线程,这个不能放在构造里，因为要先设置线程数量，才能启动它
        return _baseloop.Start();
    }
    void SetConnectedCallback(const ConnectedCallback &cb) { _connected_cb = cb; }
    void SetMessageCallback(const MessageCallback &cb) { _message_cb = cb; }
    void SetClosedCallback(const ClosedCallback &cb) { _closed_cb = cb; }
    void SetAnyEventCallback(const AnyEventCallback &cb) { _any_event_cb = cb; }
    void EnableInactiveRelease(int timeout)
    {
        _enable_inactive_release = true;
        _timeout = timeout;
    }
    void RunAfter(const Functor &task, int delay) // 添加定时任务,这是给用户自定义添加定时任务的，跟连接没有关系
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RunAfterInLoop, this, task, delay));
    }
    void RemoveConnection(const Connection::PtrConnection &conn) // 从管理的Connection的_conns中移除连接信息，这样这个连接才会真正被释放掉
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
    }

private:
    void RunAfterInLoop(const Functor &task, int delay) // 添加定时任务
    {
        _next_id++;
        _baseloop.TimerAdd(_next_id, delay, task);
    }
    void NewConnection(int fd) // 为新连接构造Connection进行管理
    {
        _next_id++;
        Connection::PtrConnection conn(new Connection(_pool.NextLoop(), _next_id++, fd));
        conn->SetMessageCallback(_message_cb);
        conn->SetClosedCallback(_closed_cb);
        conn->SetConnectedCallback(_connected_cb);
        conn->SetAnyEventCallback(_any_event_cb);
        conn->SetServerClosedCallback(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
        // 非活跃连接释放操作，timeout后，关闭连接
        // // 注意：定时销毁任务，必须启动在读事件之前，因为有可能启动了事件监控后，立即就有了事件，但是这时候还没有定时任务
        // loop->TimerAdd(id, 10, std::bind(HandleClose, channel));
        if (_enable_inactive_release)
            conn->EnableInactiveRelease(_timeout); // 启动非活跃连接释放操作
        conn->Established();                       // 就绪初始化
        _conns.insert(std::make_pair(_next_id, conn));
    }

    void RemoveConnectionInLoop(const Connection::PtrConnection &conn)
    {
        int id = conn->Id();
        auto it = _conns.find(id);
        if (it != _conns.end())
            _conns.erase(it);
    }

private:
    int _port;
    uint64_t _next_id;                                              // 连接的唯一id，便于连接的管理和查找
    int _timeout;                                                   // 这是一个非活跃连接的统计事件---多长时间无通信，就是非活跃连接
    bool _enable_inactive_release;                                  // 是否启动了非活跃连接超时销毁的判断标志
    EventLoop _baseloop;                                            // 这是主线程的EventLoopd对象，负责监听事件的处理，这里没有用指针，因为我们需要这里真正创建一个EventLoop
    Acceptor _acceptor;                                             // 监听套接字的管理对象
    LoopThreadPool _pool;                                           // 这时从属EventLoop线程池
    std::unordered_map<uint64_t, Connection::PtrConnection> _conns; // 保存所有管理连接的shared_ptr

    ConnectedCallback _connected_cb;  // 连接建立成功后的回调函数
    MessageCallback _message_cb;      // 收到数据的回调函数
    ClosedCallback _closed_cb;        // 连接关闭的回调函数
    AnyEventCallback _any_event_cb;   // 任意事件的回调函数
};

void TimerWheel::TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &task_cb)
{
    // 放到EventLoop里去执行，如果跟EventLoop在同一个线程，就直接执行，不在，就会放入任务队列
    _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, task_cb));
}
// 这里也同理，因为它也对_timers操作了
void TimerWheel::TimerRefresh(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
}
void TimerWheel::TimerCancel(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInLoop, this, id));
}
// 如果在类里面实现，因为EventLoop类在channel类下面，哪怕前置声明了，只是告诉编译器有这个类
// 但是编译器也无法知道有没有到具体的成员函数
// 所以在类里面声明，类外面定义
void Channel::Update() { _loop->UpdateEvent(this); }
// 移除监控，即从epoll的红黑树上，把对应节点移除
void Channel::Remove() { _loop->RemoveEvent(this); }

class NetWork
{
public:
    NetWork()
    {
        signal(SIGPIPE, SIG_IGN);
    }
};
static NetWork nw;

#endif